/**
 * t5 - Tobogan de Bolitas
 * Resultado no Site da URI- > Accepted 0.020
 *
 * Matheus Garay Trindade
 *
 */
#include <iostream>
#include <cmath>
#include <cstdio>

using namespace std;

//Classe ponto adaptada do formulário. Foi retirado o z e adicionado o operador =
class Point {

public:

	float x, y;

	Point() {

		x = y = 0;

	}

	Point(float x1, float y1) {

		x = x1;

		y = y1;

	}
	//Explicita uma atribuição de Pontos
	void operator = (Point a)
	{
		x = a.x;
		y = a.y;

	}
	Point operator -(Point a) {

		return Point(x - a.x, y - a.y);

	}

	Point operator +(Point a) {

		return Point(x + a.x, y + a.y);

	}

	Point operator /(float a) {

		return Point(x / a, y / a);

	}

	Point operator *(float a) {

		return Point(x * a, y * a);

	}

};

//Adaptado para produto escalar em duas dimensões. Feito a partir do formulário.
float dot(Point a, Point b) {

	return (a.x * b.x) + (a.y*b.y);

}
//Adaptado para duas diemsões a partir do formulário
float dist (Point a, Point b)
{
	return sqrt((a.x - b.x)*(a.x - b.x) + (a.y - b.y)*(a.y - b.y));

}

//Usada a partir do formulário
float distPointToSegment(Point c, Point p1, Point p2) {

	Point pV;

	pV = p2 - p1;

	Point pW;

	pW = c - p1;

	float c1 = dot(pW, pV);

	if (c1 <= 0)

		return dist(c, p1);

	float c2 = dot(pV, pV);

	if (c2 <= c1)

		return dist(c, p2);

	float b = c1 / c2;

	Point proj;

	proj = p1 + pV * b;

	return dist(c, proj);

}


int main()
{
	//Defino uma aleta como sendo um vetor de pontos de duas posições.
	//aletaN[0] ->Ponto da extremidade da aleta colado na parede. aletaN[1]->O outro ponto da extremidade da aleta
	Point aleta1[2], aleta2[2];

	int numAletas;
	//l é um vetor usado para alterar a posição de começo da aleta. l[0] é sempre 0. l[1] é sempre L, lido da entrada
	//h é a altura do brinquedo
	int l[2], h;

	//Variável que controla qual valor será lido do vetor l para formar um Ponto.
	int controla;

	//diametroCirculo é o diametro máximo que um circulo pode assumir
	double diametroCirculo;

	l[0] = 0;

	float distanciaParede;
	float distanciaAletaDeBaixo;

	float temp; //Variável auxiliar

	//Lê o descritor do brinquedo (número de aletas, largura e altura
	while(scanf("%d%d%d", &numAletas, l+1, &h) == 3) //Enquanto for possível fazer leituras, faça
	{
		//Começa sempre colado na parede da esquerda, onde xi = 0. Assim, controla começa em 0
		controla = 0;

		//Monta a primeira aleta
		aleta1[0].x = l[controla];
		scanf("%f%f%f", &aleta1[0].y, &aleta1[1].x, &aleta1[1].y);

		//Calcula um primeiro diâmetro para iniciar a variável (Calcula distância até a parede, já que já tem essa informação
		diametroCirculo = dist(aleta1[1], Point(l[(controla+1)%2], aleta1[1].x));

		//Faz um laço até a última aleta, pois em todas as outras o algoritmo é o mesmo.

		for(;numAletas > 1 ; numAletas--)
		{

			//Troca a posição de de começo da aleta para montar a aleta de baixo
			controla = (controla + 1)%2;



			//Monta a a aleta de baixo
			aleta2[0].x = l[controla];
			scanf("%f%f%f", &aleta2[0].y, &aleta2[1].x, &aleta2[1].y);



			//Calcula distância do final da aleta até a parede
			//X da parede é o mesmo x da aleta lida,logo, l[controla]. O y é o mesmo do final
			//da aleta
			distanciaParede = dist(aleta1[1], Point(l[controla], aleta1[1].y));



			//Cálcula a distância do ponto final da aleta de cima até a aleta de baixo (segmento de reta
			//dos pontos aleta2[0] até aleta2[1]
			distanciaAletaDeBaixo = distPointToSegment(aleta1[1], aleta2[0], aleta2[1]);


			//Compara o diâmetro atual do maior círculo posível com a menor das duas distâncias calculadas.
			//Se ele for maior que ela. Muda o diâmetro do maior círculo possível para a menor distância
			if(diametroCirculo > (temp = (distanciaAletaDeBaixo < distanciaParede ? distanciaAletaDeBaixo: distanciaParede)))
				diametroCirculo = temp;

			//Aleta 2 passa a ser aleta 1
			aleta1[1] = aleta2[1];
			aleta1[0] = aleta2[0];
		}

		//Falta ainda comparar última aleta
		//Descobre de qual parede irá calcular a distância
		controla = (controla + 1)%2;

		//Se o final da última aleta é menor do que zero, significa que não há parede na frente,
		//Então tem que ser calculada a distância do ultimo ponto do brinquedo que tem coordenadas (l[controla], 0)
		if(aleta1[1].y < 0)
			temp = dist(aleta1[1], Point(l[controla], 0));

		else //Se tem parede na frente, processo é o mesmo que foi feito anteriormente. Parede é (l[controla], aleta1[1].y)
			temp = dist(aleta1[1], Point(l[controla], aleta1[1].y));

		if(temp < diametroCirculo) //Se essa última distância for menor que o raior do mmaior círculo possível,
			diametroCirculo = temp; //Diminui-se o tamanho do maior círculo possível para essa distância

		printf("%.2lf\n", diametroCirculo);


	}




}
